#include "../include/mainwindow.h"
#include "../include/config.h"
#include "snakegamemanager.h"

#include <QApplication>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QScreen>
#include <QRandomGenerator>     // 随机数生成器
#include <QDateTime>            // 日期时间

/**
 * @brief MainWindow构造函数
 * @param parent 父窗口指针
 *
 * 初始化主窗口的所有组件和服务：
 * 1. 创建核心服务（认证服务、游戏服务）
 * 2. 设置初始状态和配置
 * 3. 构建用户界面
 * 4. 建立信号槽连接
 * 5. 恢复窗口状态和应用主题
 * 6. 检查认证状态并显示相应页面
 */
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , m_authService(new AuthService(this))        // 创建认证服务实例
    , m_gameService(nullptr)                      // 游戏服务实例（延迟初始化）
    , m_statusTimer(new QTimer(this))             // 创建状态更新定时器
    , m_settings(new QSettings(this))             // 创建设置管理器

    , m_snakeGameEntryWidget(nullptr)             // Snake游戏入口组件（延迟初始化）
    , m_gameAuthProgressWidget(nullptr)           // 游戏认证进度组件（延迟初始化）
    , m_snakeGameManager(nullptr)                 // Snake游戏管理器（延迟初始化）
    // 删除：空白游戏页面组件（未使用）
    // , m_blankGameWidget(nullptr)                  // 空白游戏页面组件（延迟初始化）
    , m_isAuthenticated(false)                    // 初始未认证状态
    , m_currentTheme("dark")                      // 默认使用深色主题
    , m_primaryColor("#4A90E2")                   // 主色调：蓝色
    , m_backgroundColor("#2C3E50")                // 背景色：深灰蓝
    , m_textColor("#ECF0F1")                      // 文字色：浅灰白
    , m_directDataChannel(nullptr)               // 直接数据通道（延迟初始化）
    , m_gameDataPool(nullptr)                    // 游戏数据对象池（延迟初始化）
{
    // === 初始化阶段 ===
    setupUI();              // 构建用户界面
    setupMenuBar();         // 设置菜单栏
    setupStatusBar();       // 设置状态栏
    setupSystemTray();      // 设置系统托盘
    setupConnections();     // 建立信号槽连接

    // === 状态恢复阶段 ===
    restoreWindowState();   // 恢复窗口位置和大小
    applyTheme(m_currentTheme); // 应用默认主题

    // === 认证检查阶段 ===
    // 检查用户是否已经登录（通过保存的令牌）
    if (m_authService->isAuthenticated()) {
        // 如果有保存的认证信息，验证令牌是否仍然有效
        m_authService->validateToken();
    } else {
        // 如果没有认证信息，显示登录页面
        showLoginPage();
    }

    // === 定时任务设置 ===
    // 设置状态栏定时更新，每5秒刷新一次状态信息
    connect(m_statusTimer, &QTimer::timeout, this, &MainWindow::updateStatusBar);
    m_statusTimer->start(5000); // 5秒更新一次状态

    // === 初始化专用网络线程 ===
    m_networkThread = nullptr;
    qDebug() << "MainWindow: 专用网络线程已初始化";
}

/**
 * @brief MainWindow析构函数
 *
 * 清理资源并保存当前状态：
 * - 保存窗口位置和大小
 * - 保存用户设置
 * - 清理网络连接
 */
MainWindow::~MainWindow()
{
    saveWindowState();  // 保存窗口状态到QSettings
}

/**
 * @brief 设置用户界面
 *
 * 创建和配置主窗口的所有UI组件：
 * 1. 设置窗口基本属性（标题、大小）
 * 2. 创建中央窗口部件和主布局
 * 3. 创建侧边栏组件
 * 4. 创建堆叠窗口容器
 * 5. 创建各个功能页面
 * 6. 将页面添加到堆叠容器中
 */
void MainWindow::setupUI()
{
    // === 窗口基本设置 ===
    setWindowTitle(Config::getAppName());              // 设置窗口标题
    setMinimumSize(Config::getMinimumWindowSize());    // 设置最小窗口大小

    // 初始使用登录页面大小（较小），登录后会调整为主页面大小
    resize(Config::getLoginWindowSize());

    // === 中央窗口部件设置 ===
    // 创建中央窗口部件（QMainWindow必须有一个中央部件）
    m_centralWidget = new QWidget(this);
    m_centralWidget->setObjectName("centralWidget");   // 设置对象名，用于CSS样式
    setCentralWidget(m_centralWidget);

    // 创建主布局（水平布局：侧边栏 + 主内容区）
    m_mainLayout = new QHBoxLayout(m_centralWidget);
    m_mainLayout->setContentsMargins(0, 0, 0, 0);      // 无边距，充分利用空间
    m_mainLayout->setSpacing(0);                       // 无间距，紧密布局

    // === 侧边栏设置 ===
    // 创建侧边栏组件，传入认证服务用于显示用户信息
    m_sidebarWidget = new SidebarWidget(m_authService, this);
    m_sidebarWidget->setVisible(false);                // 初始隐藏，登录后显示
    m_sidebarWidget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
    m_mainLayout->addWidget(m_sidebarWidget);

    // === 主内容区域设置 ===
    // 创建堆叠窗口容器，用于管理多个页面的切换
    m_stackedWidget = new QStackedWidget(this);
    m_stackedWidget->setObjectName("mainStackedWidget");
    m_stackedWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    m_mainLayout->addWidget(m_stackedWidget, 1);       // 使用比例拉伸，占据剩余空间

    // === 认证相关页面创建 ===
    // 创建登录页面，传入认证服务用于处理登录逻辑
    m_loginWidget = new LoginWidget(m_authService, this);
    // 创建注册页面
    m_registerWidget = new RegisterWidget(m_authService, this);
    // 创建忘记密码页面
    m_forgotPasswordWidget = new ForgotPasswordWidget(m_authService, this);

    // === 主功能页面创建 ===
    // 创建游戏服务器页面，GameService将在登录成功后设置
    m_gameServerWidget = new GameServerWidget(nullptr, m_authService, this);
    // 创建设置页面，传入认证服务用于用户相关设置
    m_settingsWidget = new SettingsWidget(m_authService, this);
    // 创建游戏认证进度页面
    m_gameAuthProgressWidget = new GameAuthProgressWidget(this);

    // 删除：空白游戏页面（未使用）
    // m_blankGameWidget = new BlankGameWidget(this);





    // 现代化游戏控制器将在需要时创建
    m_modernGameController = nullptr;

    // 创建现代化Snake游戏入口页面
    m_snakeGameEntryWidget = new ModernSnakeEntryWidget(this);

    // === 页面添加到堆叠容器 ===
    // 将所有页面添加到堆叠窗口容器中，通过索引进行切换
    m_stackedWidget->addWidget(m_loginWidget);           // 索引0：登录页面
    m_stackedWidget->addWidget(m_registerWidget);        // 索引1：注册页面
    m_stackedWidget->addWidget(m_forgotPasswordWidget);  // 索引2：忘记密码页面
    m_stackedWidget->addWidget(m_gameServerWidget);      // 索引3：游戏服务器页面
    m_stackedWidget->addWidget(m_settingsWidget);        // 索引4：设置页面
    m_stackedWidget->addWidget(m_gameAuthProgressWidget); // 索引5：游戏认证进度页面
    // 删除：空白游戏页面（未使用）
    // m_stackedWidget->addWidget(m_blankGameWidget);       // 索引6：空白游戏页面
    m_stackedWidget->addWidget(m_snakeGameEntryWidget);  // 索引7：Snake游戏入口页面


    // === 连接现代化Snake游戏入口页面信号 ===
    connect(m_snakeGameEntryWidget, &ModernSnakeEntryWidget::gameModeSelected,
            this, &MainWindow::onGameModeSelected);
    connect(m_snakeGameEntryWidget, &ModernSnakeEntryWidget::backToMainMenu,
            this, &MainWindow::showMainPage);
    connect(m_snakeGameEntryWidget, &ModernSnakeEntryWidget::settingsClicked,
            this, [this]() {
                // 非阻塞提示，避免抢焦点
                auto *msg = new QMessageBox(QMessageBox::Information, "设置", "设置功能即将推出！", QMessageBox::Ok, this);
                msg->setAttribute(Qt::WA_DeleteOnClose);
                msg->open();
            });


}

/**
 * @brief 设置菜单栏
 *
 * 创建应用程序的主菜单栏，包含：
 * 1. 游戏菜单：刷新、登出、退出
 * 2. 设置菜单：偏好设置
 * 3. 帮助菜单：关于、关于Qt
 *
 * 注意：某些菜单项在未登录状态下会被禁用
 */
void MainWindow::setupMenuBar()
{
    // === 游戏菜单 ===
    // 创建游戏菜单，使用&G设置快捷键Alt+G
    m_gameMenu = menuBar()->addMenu("游戏(&G)");

    // 刷新服务器列表动作
    m_refreshAction = new QAction("刷新服务器列表(&R)", this);
    m_refreshAction->setShortcut(QKeySequence::Refresh);    // F5快捷键
    m_refreshAction->setEnabled(false);                     // 初始禁用，登录后启用
    m_gameMenu->addAction(m_refreshAction);

    m_gameMenu->addSeparator();  // 添加分隔线

    // 登出动作
    m_logoutAction = new QAction("登出(&L)", this);
    m_logoutAction->setShortcut(QKeySequence("Ctrl+L"));    // Ctrl+L快捷键
    m_logoutAction->setEnabled(false);                      // 初始禁用，登录后启用
    m_gameMenu->addAction(m_logoutAction);

    // 退出应用程序动作
    m_exitAction = new QAction("退出(&X)", this);
    m_exitAction->setShortcut(QKeySequence::Quit);          // Ctrl+Q快捷键
    m_gameMenu->addAction(m_exitAction);

    // === 设置菜单 ===
    // 创建设置菜单，使用&S设置快捷键Alt+S
    m_settingsMenu = menuBar()->addMenu("设置(&S)");

    // 偏好设置动作
    m_settingsAction = new QAction("偏好设置(&P)", this);
    m_settingsAction->setShortcut(QKeySequence::Preferences); // 系统默认偏好设置快捷键
    m_settingsMenu->addAction(m_settingsAction);

    // === 帮助菜单 ===
    // 创建帮助菜单，使用&H设置快捷键Alt+H
    m_helpMenu = menuBar()->addMenu("帮助(&H)");

    // 关于应用程序动作
    m_aboutAction = new QAction("关于(&A)", this);
    m_helpMenu->addAction(m_aboutAction);

    // 关于Qt动作（直接连接到Qt的关于对话框）
    QAction *aboutQtAction = new QAction("关于 Qt(&Q)", this);
    connect(aboutQtAction, &QAction::triggered, qApp, &QApplication::aboutQt);
    m_helpMenu->addAction(aboutQtAction);
}

/**
 * @brief 设置状态栏
 *
 * 创建状态栏组件，显示应用程序的实时状态信息：
 * 1. 主状态标签：显示当前操作状态
 * 2. 连接状态标签：显示网络连接状态
 * 3. 用户状态标签：显示当前登录用户信息
 *
 * 状态栏布局：[主状态] | [连接状态] | [用户状态]
 */
void MainWindow::setupStatusBar()
{
    // === 主状态标签 ===
    // 显示应用程序的主要状态信息（如"就绪"、"加载中"等）
    m_statusLabel = new QLabel("就绪", this);
    statusBar()->addWidget(m_statusLabel);  // 添加到状态栏左侧（可拉伸区域）

    // === 分隔符 ===
    statusBar()->addPermanentWidget(new QLabel("|"));  // 添加分隔符

    // === 连接状态标签 ===
    // 显示网络连接状态，初始为"未连接"状态
    m_connectionLabel = new QLabel("未连接", this);
    m_connectionLabel->setStyleSheet("color: #E74C3C;");  // 红色表示未连接
    statusBar()->addPermanentWidget(m_connectionLabel);   // 添加到状态栏右侧（固定位置）

    // === 分隔符 ===
    statusBar()->addPermanentWidget(new QLabel("|"));  // 添加分隔符

    // === 用户状态标签 ===
    // 显示当前登录用户信息，初始为"未登录"状态
    m_userLabel = new QLabel("未登录", this);
    m_userLabel->setStyleSheet("color: #E74C3C;");     // 红色表示未登录
    statusBar()->addPermanentWidget(m_userLabel);      // 添加到状态栏右侧（固定位置）
}

/**
 * @brief 设置系统托盘
 *
 * 创建系统托盘图标和相关功能：
 * 1. 检查系统是否支持托盘功能
 * 2. 创建托盘图标和上下文菜单
 * 3. 添加窗口控制选项（显示、最小化、隐藏）
 * 4. 添加退出选项
 *
 * 托盘菜单选项：
 * - 显示主窗口：恢复并激活窗口
 * - 最小化到任务栏：最小化但保持任务栏图标
 * - 隐藏到系统托盘：完全隐藏窗口
 * - 退出：关闭应用程序
 */
void MainWindow::setupSystemTray()
{
    // === 系统托盘可用性检查 ===
    // 检查当前系统是否支持系统托盘功能
    if (!QSystemTrayIcon::isSystemTrayAvailable()) {
        qWarning() << "系统托盘不可用";
        return;  // 如果不支持，直接返回
    }

    // === 创建托盘图标 ===
    m_trayIcon = new QSystemTrayIcon(this);
    // 暂时使用系统默认的计算机图标，后续可以替换为自定义图标
    m_trayIcon->setIcon(style()->standardIcon(QStyle::SP_ComputerIcon));

    // === 创建托盘上下文菜单 ===
    m_trayMenu = new QMenu(this);

    // === 显示主窗口动作 ===
    // 恢复窗口并将其置于前台
    QAction *showAction = new QAction("显示主窗口", this);
    connect(showAction, &QAction::triggered, this, [this]() {
        showNormal();       // 恢复窗口到正常状态
        activateWindow();   // 激活窗口（获得焦点）
        raise();            // 将窗口置于最前面
    });
    m_trayMenu->addAction(showAction);

    // === 最小化到任务栏动作 ===
    // 最小化窗口但保持任务栏图标可见
    QAction *minimizeAction = new QAction("最小化到任务栏", this);
    connect(minimizeAction, &QAction::triggered, this, &QWidget::showMinimized);
    m_trayMenu->addAction(minimizeAction);

    // === 隐藏到系统托盘动作 ===
    // 完全隐藏窗口，只能通过托盘图标访问
    QAction *hideAction = new QAction("隐藏到系统托盘", this);
    connect(hideAction, &QAction::triggered, this, &QWidget::hide);
    m_trayMenu->addAction(hideAction);

    // === 分隔线和退出选项 ===
    m_trayMenu->addSeparator();                 // 添加分隔线
    m_trayMenu->addAction(m_exitAction);        // 添加退出动作（复用菜单栏的退出动作）

    // === 配置托盘图标 ===
    m_trayIcon->setContextMenu(m_trayMenu);     // 设置右键菜单
    m_trayIcon->show();                         // 显示托盘图标

    // === 托盘图标激活事件连接 ===
    // 处理用户点击托盘图标的事件（单击、双击等）
    connect(m_trayIcon, &QSystemTrayIcon::activated,
            this, &MainWindow::onTrayIconActivated);
}

/**
 * @brief 设置信号槽连接
 *
 * 建立所有组件之间的信号槽连接，实现组件间的通信：
 * 1. 认证服务连接：处理登录成功、认证失效等事件
 * 2. 页面切换连接：处理各页面间的跳转
 * 3. 侧边栏连接：处理导航点击事件
 * 4. 菜单动作连接：处理菜单项点击事件
 *
 * 这是整个应用程序事件驱动架构的核心部分
 */
void MainWindow::setupConnections()
{
    // === 认证服务连接 ===
    // 监听认证服务的状态变化
    connect(m_authService, &AuthService::loginSucceeded,
            this, &MainWindow::onLoginSucceeded);           // 登录成功处理
    connect(m_authService, &AuthService::authenticationRequired,
            this, &MainWindow::onAuthenticationRequired);   // 需要重新认证处理

    // === 登录页面连接 ===
    // 处理登录页面的各种用户操作
    connect(m_loginWidget, &LoginWidget::loginSucceeded,
            this, &MainWindow::onLoginSucceeded);           // 登录成功
    connect(m_loginWidget, &LoginWidget::switchToRegister,
            this, &MainWindow::onSwitchToRegister);         // 切换到注册页面
    connect(m_loginWidget, &LoginWidget::switchToForgotPassword,
            this, &MainWindow::onSwitchToForgotPassword);   // 切换到忘记密码页面

    // === 注册页面连接 ===
    // 处理注册页面的返回操作
    connect(m_registerWidget, &RegisterWidget::switchToLogin,
            this, &MainWindow::onSwitchToLogin);            // 返回登录页面

    // === 忘记密码页面连接 ===
    // 处理忘记密码页面的返回操作
    connect(m_forgotPasswordWidget, &ForgotPasswordWidget::switchToLogin,
            this, &MainWindow::onSwitchToLogin);            // 返回登录页面

    // === 游戏服务器页面连接 ===
    // 处理游戏加入请求
    connect(m_gameServerWidget, &GameServerWidget::gameJoinRequested,
            this, &MainWindow::onGameJoinRequested);        // 处理加入游戏请求

    // 处理Snake游戏连接就绪信号
    connect(m_gameServerWidget, &GameServerWidget::snakeGameConnectionReady,
            this, &MainWindow::onSnakeGameConnectionReady); // 处理Snake游戏连接就绪

    // === 游戏认证进度页面连接 ===
    // 处理认证进度页面的信号
    connect(m_gameAuthProgressWidget, &GameAuthProgressWidget::authenticationCancelled,
            this, &MainWindow::onAuthenticationCancelled);  // 认证取消处理
    connect(m_gameAuthProgressWidget, &GameAuthProgressWidget::authenticationCompleted,
            this, &MainWindow::onAuthenticationCompleted);  // 认证完成处理
    connect(m_gameAuthProgressWidget, &GameAuthProgressWidget::authenticationFailed,
            this, &MainWindow::onAuthenticationFailed);     // 认证失败处理
    connect(m_gameAuthProgressWidget, &GameAuthProgressWidget::retryAuthentication,
            this, &MainWindow::onRetryAuthentication);      // 重试认证处理

    // 删除：空白游戏页面信号连接（未使用）
    // connect(m_blankGameWidget, &BlankGameWidget::backToMainPage,
    //         this, &MainWindow::showMainPage);               // 返回主页面
    // connect(m_blankGameWidget, &BlankGameWidget::pageReady,
    //         this, &MainWindow::onBlankGamePageReady);       // 页面准备就绪

    // === 设置页面连接 ===
    // 处理设置变更事件
    connect(m_settingsWidget, &SettingsWidget::themeChanged,
            this, &MainWindow::onThemeChanged);             // 主题变更处理

    // === 侧边栏导航连接 ===
    // 处理侧边栏各个导航按钮的点击事件

    // 游戏服务器导航 - 切换到游戏服务器页面
    connect(m_sidebarWidget, &SidebarWidget::gameServersClicked,
            [this]() { m_stackedWidget->setCurrentWidget(m_gameServerWidget); });

    // 设置导航 - 切换到设置页面
    connect(m_sidebarWidget, &SidebarWidget::settingsClicked,
            [this]() { m_stackedWidget->setCurrentWidget(m_settingsWidget); });

    // 登出导航 - 执行登出操作
    connect(m_sidebarWidget, &SidebarWidget::logoutClicked,
            this, &MainWindow::onLogoutTriggered);

    // 退出游戏导航 - 返回游戏服务器选择界面
    connect(m_sidebarWidget, &SidebarWidget::exitGameClicked,
            this, &MainWindow::onExitGameClicked);

    // === 未实现功能的占位连接 ===
    // 这些功能尚未实现，暂时显示通知消息

    // 好友系统（开发中）
    connect(m_sidebarWidget, &SidebarWidget::friendsClicked,
            [this]() { showNotification("好友系统", "好友功能即将推出！"); });

    // 游戏统计（开发中）
    connect(m_sidebarWidget, &SidebarWidget::statisticsClicked,
            [this]() { showNotification("游戏统计", "统计功能即将推出！"); });

    // 个人资料（开发中）
    connect(m_sidebarWidget, &SidebarWidget::profileClicked,
            [this]() { showNotification("个人资料", "个人资料编辑即将推出！"); });

    // 帮助支持（开发中）
    connect(m_sidebarWidget, &SidebarWidget::helpClicked,
            [this]() { showNotification("帮助", "帮助文档即将推出！"); });

    // === 菜单动作连接 ===
    // 将菜单栏的动作连接到对应的槽函数
    connect(m_logoutAction, &QAction::triggered, this, &MainWindow::onLogoutTriggered);
    connect(m_settingsAction, &QAction::triggered, this, &MainWindow::onSettingsTriggered);
    connect(m_aboutAction, &QAction::triggered, this, &MainWindow::onAboutTriggered);
    connect(m_exitAction, &QAction::triggered, this, &MainWindow::onExitTriggered);
}

/**
 * @brief 登录成功处理槽
 *
 * 当用户成功登录时执行的操作：
 * 1. 更新认证状态
 * 2. 更新侧边栏用户信息
 * 3. 切换到主页面
 * 4. 更新窗口标题和状态栏
 * 5. 调整窗口大小
 * 6. 显示欢迎通知
 */
void MainWindow::onLoginSucceeded()
{
    // === 更新认证状态 ===
    m_isAuthenticated = true;

    // === 初始化游戏服务 ===
    // 使用AuthService的ApiClient实例，确保认证令牌共享
    if (!m_gameService) {
        m_gameService = new GameService(m_authService->getApiClient(), this);

        // 将GameService实例传递给GameServerWidget
        m_gameServerWidget->setGameService(m_gameService);

        qDebug() << "MainWindow: GameService initialized with shared ApiClient";
    }

    // === 更新用户界面 ===
    // 获取当前用户信息并更新侧边栏显示
    AuthService::UserInfo userInfo = m_authService->getCurrentUser();
    m_sidebarWidget->updateUserInfo(userInfo);

    // === 页面和界面切换 ===
    showMainPage();         // 显示主功能页面
    updateWindowTitle();    // 更新窗口标题
    updateStatusBar();      // 更新状态栏信息

    // === 窗口大小调整 ===
    // 从登录页面的小窗口调整为主页面的大窗口
    adjustWindowSizeForMode(true);

    // === 用户反馈 ===
    showNotification("登录成功", "欢迎回来，游戏服务已就绪!");
}

/**
 * @brief 切换到注册页面槽
 *
 * 从登录页面切换到注册页面：
 * 1. 切换堆叠窗口到注册页面
 * 2. 隐藏菜单栏和状态栏（注册页面不需要）
 */
void MainWindow::onSwitchToRegister()
{
    // === 页面切换 ===
    m_stackedWidget->setCurrentWidget(m_registerWidget);

    // === 界面简化 ===
    // 隐藏菜单栏和状态栏，让注册页面更简洁
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);
    m_sidebarWidget->setVisible(false);

    // === 更新界面状态 ===
    updateWindowTitle();
}

/**
 * @brief 切换到登录页面槽
 *
 * 从其他页面切换回登录页面：
 * 1. 切换堆叠窗口到登录页面
 * 2. 隐藏菜单栏、状态栏和侧边栏
 * 3. 更新窗口标题
 */
void MainWindow::onSwitchToLogin()
{
    // === 页面切换 ===
    m_stackedWidget->setCurrentWidget(m_loginWidget);

    // === 界面简化 ===
    // 隐藏所有非必要的界面元素，只保留登录表单
    menuBar()->setVisible(false);       // 隐藏菜单栏
    statusBar()->setVisible(false);     // 隐藏状态栏
    m_sidebarWidget->setVisible(false); // 隐藏侧边栏

    // === 更新界面状态 ===
    updateWindowTitle();
}

/**
 * @brief 切换到忘记密码页面槽
 *
 * 从登录页面切换到忘记密码页面：
 * 1. 切换堆叠窗口到忘记密码页面
 * 2. 隐藏菜单栏、状态栏和侧边栏
 * 3. 更新窗口标题
 */
void MainWindow::onSwitchToForgotPassword()
{
    // === 页面切换 ===
    m_stackedWidget->setCurrentWidget(m_forgotPasswordWidget);

    // === 界面简化 ===
    // 隐藏所有非必要的界面元素，专注于密码重置流程
    menuBar()->setVisible(false);       // 隐藏菜单栏
    statusBar()->setVisible(false);     // 隐藏状态栏
    m_sidebarWidget->setVisible(false); // 隐藏侧边栏

    // === 更新界面状态 ===
    updateWindowTitle();
}

/**
 * @brief 需要重新认证槽
 *
 * 当令牌过期或认证失效时调用：
 * 1. 更新认证状态为未认证
 * 2. 切换到登录页面
 * 3. 更新界面状态
 * 4. 调整窗口大小
 * 5. 显示提示通知
 */
void MainWindow::onAuthenticationRequired()
{
    // === 更新认证状态 ===
    m_isAuthenticated = false;

    // === 界面切换 ===
    showLoginPage();        // 切换到登录页面
    updateWindowTitle();    // 更新窗口标题
    updateStatusBar();      // 更新状态栏

    // === 窗口大小调整 ===
    // 从主页面的大窗口调整为登录页面的小窗口
    adjustWindowSizeForMode(false);

    // === 用户提示 ===
    showNotification("需要重新登录", "您的登录已过期，请重新登录");
}

/**
 * @brief 登出触发槽
 *
 * 处理用户主动登出操作：
 * 1. 显示确认对话框
 * 2. 如果用户确认，执行登出操作
 * 3. 调用认证失效处理流程
 */
void MainWindow::onLogoutTriggered()
{
    // === 用户确认 ===
    // 显示确认对话框，防止误操作
    int ret = QMessageBox::question(this, "确认登出",
        "确定要登出吗？",
        QMessageBox::Yes | QMessageBox::No);

    // === 执行登出 ===
    if (ret == QMessageBox::Yes) {
        m_authService->logout();        // 清除认证信息
        onAuthenticationRequired();     // 执行认证失效处理流程
    }
}

/**
 * @brief 设置触发槽
 *
 * 处理用户点击设置菜单的操作：
 * 1. 检查用户是否已认证
 * 2. 如果已认证，切换到设置页面
 * 3. 更新窗口标题
 */
void MainWindow::onSettingsTriggered()
{
    // === 认证检查 ===
    // 只有已登录用户才能访问设置页面
    if (m_isAuthenticated) {
        // === 页面切换 ===
        m_stackedWidget->setCurrentWidget(m_settingsWidget);

        // === 更新界面状态 ===
        updateWindowTitle();
    }
}

/**
 * @brief 关于对话框触发槽
 *
 * 显示应用程序的关于信息：
 * 1. 构建包含应用信息的HTML文本
 * 2. 显示关于对话框
 *
 * 包含的信息：
 * - 应用程序名称和版本
 * - 功能描述
 * - 技术栈信息
 * - 开发团队
 * - 版权信息
 */
void MainWindow::onAboutTriggered()
{
    // === 构建关于信息 ===
    // 使用HTML格式构建美观的关于文本
    QString aboutText = QString(
        "<h2>%1</h2>"                                           // 应用程序名称
        "<p>版本: %2</p>"                                       // 版本号
        "<p>这是一个基于Qt开发的现代化游戏客户端。</p>"              // 功能描述
        "<p>支持多种游戏类型和服务器连接。</p>"                    // 特性说明
        "<p><b>技术栈:</b> Qt 6, C++, 微服务架构</p>"            // 技术信息
        "<p><b>开发团队:</b> 29108</p>"                         // 开发团队
        "<p>Copyright © 2024 All rights reserved.</p>"         // 版权信息
    ).arg(Config::getAppName(), Config::getAppVersion());

    // === 显示关于对话框 ===
    QMessageBox::about(this, "关于", aboutText);
}

/**
 * @brief 退出应用触发槽
 *
 * 处理用户退出应用程序的操作：
 * 1. 显示确认对话框
 * 2. 如果用户确认，执行清理操作
 * 3. 退出应用程序
 *
 * 注意：这是通过菜单触发的退出，会直接退出程序
 */
void MainWindow::onExitTriggered()
{
    // === 创建确认对话框 ===
    QMessageBox msgBox(this);
    msgBox.setWindowTitle("确认退出");
    msgBox.setText("确定要退出应用程序吗？");
    msgBox.setInformativeText("所有未保存的数据将会丢失。");
    msgBox.setIcon(QMessageBox::Question);
    msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    msgBox.setDefaultButton(QMessageBox::No);               // 默认选择"取消"，防止误操作

    // === 自定义按钮文本 ===
    msgBox.button(QMessageBox::Yes)->setText("确定退出");
    msgBox.button(QMessageBox::No)->setText("取消");

    // === 执行退出操作 ===
    if (msgBox.exec() == QMessageBox::Yes) {
        // 用户确认退出，执行清理并退出
        cleanupBeforeExit();        // 清理资源
        QApplication::quit();       // 直接退出程序
    }
}

/**
 * @brief 退出前清理
 *
 * 在应用程序退出前执行必要的清理工作：
 * 1. 保存窗口状态和用户设置
 * 2. 隐藏和清理系统托盘图标
 * 3. 清理网络连接和其他资源
 */
void MainWindow::cleanupBeforeExit()
{
    // === 保存应用状态 ===
    saveWindowState();          // 保存窗口位置、大小等状态

    // === 清理系统托盘 ===
    if (m_trayIcon) {
        m_trayIcon->hide();         // 隐藏托盘图标
        m_trayIcon->deleteLater();  // 延迟删除对象
        m_trayIcon = nullptr;       // 清空指针
    }

    // 断开所有网络连接
    if (m_authService) {
        m_authService->logout();
    }

    // 保存设置
    if (m_settings) {
        m_settings->sync();
    }

    // 显示退出提示
    if (m_trayIcon && m_trayIcon->supportsMessages()) {
        showNotification("应用退出", "感谢使用，再见！");
    }
}

void MainWindow::onTrayIconActivated(QSystemTrayIcon::ActivationReason reason)
{
    switch (reason) {
    case QSystemTrayIcon::Trigger:
    case QSystemTrayIcon::DoubleClick:
        if (isVisible() && !isMinimized()) {
            // 如果窗口可见且未最小化，则隐藏到系统托盘
            hide();
        } else {
            // 如果窗口隐藏或最小化，则显示并激活窗口
            showNormal();
            activateWindow();
            raise();
        }
        break;
    default:
        break;
    }
}

void MainWindow::onThemeChanged(const QString &theme)
{
    m_currentTheme = theme;
    applyTheme(theme);

    // 同步更新侧边栏主题
    if (m_sidebarWidget) {
        m_sidebarWidget->setTheme(theme);
    }
}

void MainWindow::onGameJoinRequested(const QString &gameType)
{
    qDebug() << "MainWindow: Game join requested for type:" << gameType;

    // === 检查认证状态 ===
    if (!m_isAuthenticated) {
        auto *msg = new QMessageBox(QMessageBox::Warning, "需要登录", "请先登录后再加入游戏", QMessageBox::Ok, this);
        msg->setAttribute(Qt::WA_DeleteOnClose);
        msg->open();
        return;
    }

    // === 获取选中的服务器信息 ===
    GameService::GameServer selectedServer;
    if (m_gameServerWidget) {
        selectedServer = m_gameServerWidget->getSelectedServer();
    }

    // === 检查服务器信息是否有效 ===
    if (selectedServer.serverId.isEmpty()) {
        auto *msg = new QMessageBox(QMessageBox::Warning, "服务器未选择", "请先选择一个游戏服务器", QMessageBox::Ok, this);
        msg->setAttribute(Qt::WA_DeleteOnClose);
        msg->open();
        return;
    }

    // === 确保认证进度组件状态重置 ===
    m_gameAuthProgressWidget->resetAuthentication();
    qDebug() << "MainWindow: 强制重置认证进度组件状态";

    // === 显示认证进度页面 ===
    m_stackedWidget->setCurrentWidget(m_gameAuthProgressWidget);

    // === 开始认证流程 ===
    m_gameAuthProgressWidget->startAuthentication(selectedServer, gameType);
    
    // === 更新状态栏 ===
    m_statusLabel->setText(QString("正在认证%1游戏...").arg(gameType.toUpper()));
    m_connectionLabel->setText("认证中");
    m_connectionLabel->setStyleSheet("color: #F39C12;");

    // === 调用真实的游戏认证API ===
    if (m_gameService) {
        // 连接信号以处理认证结果
        connect(m_gameService, &GameService::gameJoinSucceeded,
                this, &MainWindow::onGameAuthenticationSucceeded, Qt::UniqueConnection);
        connect(m_gameService, &GameService::gameJoinFailed,
                this, &MainWindow::onGameAuthenticationFailed, Qt::UniqueConnection);
        
        // 更新认证进度
        m_gameAuthProgressWidget->updateAuthStep(
            GameAuthProgressWidget::Authenticating, 
            "正在验证游戏权限..."
        );
        
        // 调用真实的游戏加入API（注意参数顺序：gameType, serverPreference）
        m_gameService->joinGame(selectedServer.gameType, selectedServer.serverId);

        qDebug() << "MainWindow: 开始真实游戏认证，服务器ID:" << selectedServer.serverId;
    } else {
        qWarning() << "MainWindow: GameService未初始化，无法进行游戏认证";
        onAuthenticationFailed("游戏服务未初始化");
    }
}

/**
 * @brief 处理Snake游戏连接就绪信号
 * @param result 游戏认证结果
 *
 * 当Snake游戏认证成功并准备建立WebSocket连接时调用
 */
void MainWindow::onSnakeGameConnectionReady(const GameService::GameLoginResult &result)
{
    qDebug() << "MainWindow: Snake game connection ready";

    // 旧SnakeGameWidget路径已移除，此方法保留作为兼容日志
    qDebug() << "MainWindow: 旧版SnakeGameWidget路径已废弃";

    // === 获取WebSocket连接信息 ===
    QString websocketUrl = result.gameConfig.value("websocket_url").toString();
    QString gameToken = result.sessionToken;
    QString playerId = result.gameConfig.value("player_id").toString();
    QString sessionId = result.sessionId;

    if (websocketUrl.isEmpty()) {
        qWarning() << "WebSocket URL is empty";
        return;
    }

    qDebug() << "MainWindow: WebSocket URL:" << websocketUrl;
    qDebug() << "MainWindow: Game Token:" << gameToken.left(20) << "...";
    qDebug() << "MainWindow: Player ID:" << playerId;
    qDebug() << "MainWindow: Session ID:" << sessionId;

    // === 建立WebSocket连接 ===
    // 这里可以调用SnakeGameWidget的方法来建立WebSocket连接
    // 或者直接在这里处理WebSocket连接逻辑

    // 旧SnakeGameWidget界面已彻底移除，仅保留现代化路径

    // === 更新状态栏 ===
    m_statusLabel->setText("🐍 Snake游戏连接已建立");
    m_connectionLabel->setText("已连接");
    m_connectionLabel->setStyleSheet("color: #27AE60;");

    qDebug() << "MainWindow: Snake game connection established successfully";
}

void MainWindow::updateStatusBar()
{
    if (m_isAuthenticated) {
        AuthService::UserInfo userInfo = m_authService->getCurrentUser();
        m_userLabel->setText(QString("用户: %1").arg(userInfo.username));
        m_userLabel->setStyleSheet("color: #27AE60;");

        m_connectionLabel->setText("已连接");
        m_connectionLabel->setStyleSheet("color: #27AE60;");
    } else {
        m_userLabel->setText("未登录");
        m_userLabel->setStyleSheet("color: #E74C3C;");

        m_connectionLabel->setText("未连接");
        m_connectionLabel->setStyleSheet("color: #E74C3C;");
    }
}

void MainWindow::showLoginPage()
{
    m_stackedWidget->setCurrentWidget(m_loginWidget);
    m_sidebarWidget->setVisible(false);

    // 隐藏菜单栏和状态栏 - 登录页面不需要
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);

    // 禁用需要认证的菜单项
    m_refreshAction->setEnabled(false);
    m_logoutAction->setEnabled(false);
    m_settingsAction->setEnabled(false);
}

void MainWindow::showMainPage()
{
    // === 确保使用正确的中央组件布局 ===
    if (centralWidget() != m_centralWidget) {
        setCentralWidget(m_centralWidget);
    }

    m_stackedWidget->setCurrentWidget(m_gameServerWidget);
    m_sidebarWidget->setVisible(true);

    // 显示菜单栏和状态栏 - 主页面需要
    menuBar()->setVisible(true);
    statusBar()->setVisible(true);

    // 启用需要认证的菜单项
    m_refreshAction->setEnabled(true);
    m_logoutAction->setEnabled(true);
    m_settingsAction->setEnabled(true);

    // === 更新窗口标题 ===
    updateWindowTitle();
}

void MainWindow::updateWindowTitle()
{
    QString title = Config::getAppName();

    if (m_isAuthenticated) {
        AuthService::UserInfo userInfo = m_authService->getCurrentUser();
        title += QString(" - %1").arg(userInfo.username);
    }

    QWidget *currentWidget = m_stackedWidget->currentWidget();
    if (currentWidget == m_registerWidget) {
        title += " - 注册";
    } else if (currentWidget == m_forgotPasswordWidget) {
        title += " - 找回密码";
    } else if (currentWidget == m_settingsWidget) {
        title += " - 设置";
    }

    setWindowTitle(title);
}

void MainWindow::showNotification(const QString &title, const QString &message)
{
    if (m_trayIcon && m_trayIcon->isVisible()) {
        m_trayIcon->showMessage(title, message, QSystemTrayIcon::Information, 3000);
    }
}

void MainWindow::adjustWindowSizeForMode(bool isAuthenticated)
{
    if (isAuthenticated) {
        // 登录后使用较大窗口
        if (size().width() < Config::getDefaultWindowSize().width()) {
            resize(Config::getDefaultWindowSize());
            // 居中显示
            QRect screenGeometry = QApplication::primaryScreen()->geometry();
            int x = (screenGeometry.width() - width()) / 2;
            int y = (screenGeometry.height() - height()) / 2;
            move(x, y);
        }
    } else {
        // 登录前使用较小窗口
        resize(Config::getLoginWindowSize());
        // 居中显示
        QRect screenGeometry = QApplication::primaryScreen()->geometry();
        int x = (screenGeometry.width() - width()) / 2;
        int y = (screenGeometry.height() - height()) / 2;
        move(x, y);
    }
}

void MainWindow::applyTheme(const QString &theme)
{
    QString styleSheet;

    if (theme == "dark") {
        m_primaryColor = "#4A90E2";
        m_backgroundColor = "#2C3E50";
        m_textColor = "#ECF0F1";
    } else if (theme == "light") {
        m_primaryColor = "#3498DB";
        m_backgroundColor = "#ECF0F1";
        m_textColor = "#2C3E50";
    }

    styleSheet = QString(R"(
        QMainWindow {
            background-color: %1;
            color: %2;
        }

        #centralWidget {
            background-color: %1;
        }

        #mainStackedWidget {
            background-color: %1;
        }

        QMenuBar {
            background-color: %1;
            color: %2;
            border-bottom: 1px solid #34495E;
        }

        QMenuBar::item {
            background-color: transparent;
            padding: 8px 12px;
        }

        QMenuBar::item:selected {
            background-color: %3;
            color: white;
        }

        QMenu {
            background-color: %1;
            color: %2;
            border: 1px solid #34495E;
        }

        QMenu::item {
            padding: 8px 25px;
        }

        QMenu::item:selected {
            background-color: %3;
            color: white;
        }

        QStatusBar {
            background-color: %1;
            color: %2;
            border-top: 1px solid #34495E;
        }

        QStatusBar QLabel {
            color: %2;
            padding: 2px 8px;
        }
    )").arg(m_backgroundColor, m_textColor, m_primaryColor);

    setStyleSheet(styleSheet);
    
    // === 如果游戏认证进度组件存在，也应用统一主题 ===
    if (m_gameAuthProgressWidget) {
        m_gameAuthProgressWidget->applyUnifiedTheme();
    }
}

void MainWindow::saveWindowState()
{
    m_settings->setValue("window/geometry", saveGeometry());
    m_settings->setValue("window/state", saveState());
    m_settings->setValue("theme", m_currentTheme);
}

void MainWindow::restoreWindowState()
{
    QByteArray geometry = m_settings->value("window/geometry").toByteArray();
    if (!geometry.isEmpty()) {
        restoreGeometry(geometry);
    }

    QByteArray state = m_settings->value("window/state").toByteArray();
    if (!state.isEmpty()) {
        restoreState(state);
    }

    m_currentTheme = m_settings->value("theme", "dark").toString();
}

void MainWindow::closeEvent(QCloseEvent *event)
{
    // 创建自定义确认对话框
    QMessageBox msgBox(this);
    msgBox.setWindowTitle("确认操作");
    msgBox.setText("您要如何处理应用程序？");
    msgBox.setInformativeText("选择您希望的操作：");
    msgBox.setIcon(QMessageBox::Question);

    // 添加自定义按钮
    QPushButton *exitButton = msgBox.addButton("退出程序", QMessageBox::YesRole);
    QPushButton *minimizeTaskbarButton = msgBox.addButton("最小化到任务栏", QMessageBox::NoRole);
    QPushButton *hideTrayButton = nullptr;
    if (m_trayIcon && m_trayIcon->isVisible()) {
        hideTrayButton = msgBox.addButton("隐藏到系统托盘", QMessageBox::NoRole);
    }
    QPushButton *cancelButton = msgBox.addButton("取消", QMessageBox::RejectRole);

    msgBox.setDefaultButton(minimizeTaskbarButton); // 默认选择最小化到任务栏
    msgBox.exec();

    QAbstractButton *clickedButton = msgBox.clickedButton();

    if (clickedButton == exitButton) {
        // 用户确认退出
        cleanupBeforeExit();
        event->accept();
        QApplication::quit(); // 确保程序完全退出
    } else if (clickedButton == minimizeTaskbarButton) {
        // 用户选择最小化到任务栏
        showMinimized();
        event->ignore();
    } else if (clickedButton == hideTrayButton) {
        // 用户选择隐藏到系统托盘
        hide();
        event->ignore();

        if (!m_settings->value("hide_notification_shown", false).toBool()) {
            showNotification("应用已隐藏", "应用已隐藏到系统托盘，双击托盘图标可重新打开");
            m_settings->setValue("hide_notification_shown", true);
        }
    } else {
        // 用户取消
        event->ignore();
    }
}

void MainWindow::resizeEvent(QResizeEvent *event)
{
    QMainWindow::resizeEvent(event);
    // 可以在这里处理窗口大小变化
}

void MainWindow::changeEvent(QEvent *event)
{
    QMainWindow::changeEvent(event);

    // 移除强制隐藏逻辑，让用户可以正常最小化到任务栏
    // 如果用户想要隐藏到系统托盘，可以通过关闭按钮或托盘菜单来实现
}

// 删除：showSnakeGamePage方法（未使用）

/**
 * @brief 显示Snake游戏入口页面
 *
 * 切换到Snake游戏入口页面，显示游戏模式选择界面
 */
void MainWindow::showSnakeGameEntryPage()
{
    qDebug() << "MainWindow: 显示Snake游戏入口页面";

    // === 保留侧边栏，只清空右边内容区域 ===
    // 确保主界面布局正常（侧边栏 + 堆叠窗口）
    if (centralWidget() != m_centralWidget) {
        // 如果当前中央组件不是主界面，恢复主界面布局
        setCentralWidget(m_centralWidget);
    }

    // === 保持侧边栏可见 ===
    if (m_sidebarWidget) {
        m_sidebarWidget->setVisible(true);
    }

    // === 切换到Snake游戏入口页面 ===
    m_stackedWidget->setCurrentWidget(m_snakeGameEntryWidget);

    // === 保持菜单栏和状态栏可见 ===
    menuBar()->setVisible(true);
    statusBar()->setVisible(true);

    // === 设置侧边栏为游戏模式 ===
    m_sidebarWidget->setExitButtonMode(true);

    // === 更新窗口标题 ===
    setWindowTitle("Snake Game - 选择游戏模式");

    qDebug() << "MainWindow: Snake游戏入口页面显示完成";
}

// 删除：Snake游戏相关槽函数（未使用）

/**
 * @brief 认证取消槽
 *
 * 当用户取消游戏认证时调用
 */
void MainWindow::onAuthenticationCancelled()
{
    qDebug() << "MainWindow: Game authentication cancelled by user";
    
    // === 返回主页面 ===
    showMainPage();
    
    // === 更新状态栏 ===
    m_statusLabel->setText("认证已取消");
    m_connectionLabel->setText("未连接");
    m_connectionLabel->setStyleSheet("color: #E74C3C;");
}

/**
 * @brief 认证完成槽
 * @param result 认证结果
 *
 * 当游戏认证成功完成时调用
 */
void MainWindow::onAuthenticationCompleted(const GameService::GameLoginResult &result)
{
    qDebug() << "MainWindow: Game authentication completed successfully";
    
    // === 保存认证结果供后续使用 ===
    m_currentGameLoginResult = result;

    // === 构建WebSocket URL（优先使用服务器提供的配置） ===
    QString websocketUrl;

    // 优先级1：直接使用服务器提供的WebSocket URL
    if (result.gameConfig.contains("websocket_url")) {
        websocketUrl = result.gameConfig["websocket_url"].toString();
        qDebug() << "MainWindow: 使用服务器提供的WebSocket URL:" << websocketUrl;
    }
    // 优先级2：使用服务器提供的WebSocket端口
    else if (result.gameConfig.contains("websocket_port")) {
        int wsPort = result.gameConfig["websocket_port"].toInt();
        if (wsPort > 0) {
            websocketUrl = QString("ws://%1:%2").arg(result.serverInfo.host).arg(wsPort);
            qDebug() << "MainWindow: 使用服务器提供的WebSocket端口:" << wsPort;
        }
    }
    // 优先级3：使用默认计算（避免硬编码）
    else {
        int websocketPort = (result.serverInfo.port == 8084) ? 8085 : result.serverInfo.port + 1;
        websocketUrl = QString("ws://%1:%2").arg(result.serverInfo.host).arg(websocketPort);
        qDebug() << "MainWindow: 使用计算的WebSocket端口:" << websocketPort;
    }
    QString playerId = result.gameConfig["player_id"].toString();  // 使用服务器返回的player_id
    QString playerName = result.gameConfig["nickname"].toString();  // 使用服务器返回的nickname

    qDebug() << "MainWindow: 准备建立WebSocket连接";
    qDebug() << "  WebSocket URL:" << websocketUrl;
    qDebug() << "  Player ID:" << playerId;
    qDebug() << "  Player Name:" << playerName;
    qDebug() << "  Session Token Length:" << result.sessionToken.length();

    // === 保存游戏会话信息供后续使用 ===
    m_currentGameSession.websocketUrl = websocketUrl;
    m_currentGameSession.gameToken = result.sessionToken;  // 保存session_token用于WebSocket认证
    m_currentGameSession.playerId = playerId;
    m_currentGameSession.playerName = playerName;

    // === 创建并启动网络线程 ===
    qDebug() << "MainWindow: 创建网络线程进行WebSocket连接";
    createNetworkThread();

    // === 更新状态栏 ===
    QString message = QString("🎮 %1游戏认证成功").arg(result.serverInfo.gameType.toUpper());
    m_statusLabel->setText(message);
    m_connectionLabel->setText("连接中");
    m_connectionLabel->setStyleSheet("color: #F39C12;");

    qDebug() << "MainWindow: HTTP认证完成，网络线程已创建";
}

/**
 * @brief 创建网络线程
 *
 * 在游戏认证成功后创建网络线程，负责WebSocket连接和游戏通信
 */
void MainWindow::createNetworkThread()
{
    // 清理旧的网络线程
    if (m_networkThread) {
        qDebug() << "MainWindow: 清理旧的网络线程";
        m_networkThread->quit();
        m_networkThread->wait();
        m_networkThread->deleteLater();
        m_networkThread = nullptr;
    }

    // 创建新的网络线程
    qDebug() << "MainWindow: 创建新的网络线程";
    m_networkThread = new NetworkThread(this);

    // 连接网络线程信号
    connect(m_networkThread, &NetworkThread::connected,
            this, &MainWindow::onWebSocketConnected);
    connect(m_networkThread, &NetworkThread::authenticated,
            this, [this]() {
                QJsonObject emptyAuthResult;
                onWebSocketAuthenticated(emptyAuthResult);
            });
    connect(m_networkThread, &NetworkThread::disconnected,
            this, &MainWindow::onWebSocketConnectionError);
    connect(m_networkThread, &NetworkThread::gameMessageReceived,
            this, &MainWindow::onNetworkGameMessage);
    connect(m_networkThread, &NetworkThread::connectionError,
            this, &MainWindow::onWebSocketConnectionError);

    qDebug() << "MainWindow: 网络线程信号已连接";

    // 启动网络线程
    qDebug() << "MainWindow: 启动网络线程";
    m_networkThread->start();

    // 构建网络配置
    NetworkWebSocketConfig config;
    config.url = m_currentGameSession.websocketUrl;
    config.gameToken = m_authService->getToken();           // 用户的access_token
    config.sessionToken = m_currentGameSession.gameToken;   // HTTP认证获得的session_token
    config.playerId = m_currentGameSession.playerId;
    config.playerName = m_currentGameSession.playerName;
    config.clientType = "qt6";
    config.protocolVersion = "1.0";
    config.heartbeatInterval = 30000;
    config.autoReconnect = false;
    config.maxReconnectAttempts = 0;

    // 开始连接
    m_networkThread->connectToGameServer(config);
}

/**
 * @brief 开始WebSocket连接和认证流程（已废弃）
 *
 * HTTP认证成功后，建立WebSocket连接并进行WebSocket认证
 */
void MainWindow::startWebSocketConnectionAndAuth()
{
    qDebug() << "MainWindow: startWebSocketConnectionAndAuth方法已废弃，使用createNetworkThread代替";
    // 这个方法已经被createNetworkThread替代，保留只是为了兼容性
}

/**
 * @brief WebSocket连接成功处理
 *
 * WebSocket连接建立成功，收到welcome消息后调用
 */
void MainWindow::onWebSocketConnected()
{
    qDebug() << "MainWindow: WebSocket连接成功，开始WebSocket认证";

    // === 更新认证进度 ===
    m_gameAuthProgressWidget->updateAuthStep(
        GameAuthProgressWidget::GettingToken,
        "WebSocket连接成功，正在进行身份认证..."
    );

    // WebSocket认证会自动进行，等待认证结果
}

/**
 * @brief WebSocket认证成功处理
 *
 * WebSocket认证成功后调用，此时可以进入游戏大厅
 */
void MainWindow::onWebSocketAuthenticated(const QJsonObject &authResult)
{
    qDebug() << "MainWindow: WebSocket认证成功，直接进入游戏大厅";
    qDebug() << "  认证结果:" << authResult;

    // === 断开GameService信号连接，防止重复触发认证流程 ===
    if (m_gameService) {
        disconnect(m_gameService, &GameService::gameJoinSucceeded,
                   this, &MainWindow::onGameAuthenticationSucceeded);
        disconnect(m_gameService, &GameService::gameJoinFailed,
                   this, &MainWindow::onGameAuthenticationFailed);
        qDebug() << "MainWindow: 已断开GameService信号连接，防止循环";
    }

    // === 直接切换到游戏大厅，不触发认证完成流程 ===
    m_stackedWidget->setCurrentWidget(m_snakeGameEntryWidget);

    // === 隐藏侧边栏和菜单栏，专注游戏体验 ===
    m_sidebarWidget->setVisible(false);
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);

    // === 调整窗口大小为游戏模式 ===
    resize(1400, 900);

    // === 更新窗口标题 ===
    setWindowTitle("Snake Game - 游戏大厅");

    // === 设置玩家信息 ===
    m_snakeGameEntryWidget->setPlayerInfo(m_currentGameSession.playerId, m_currentGameSession.playerName);

    // === 更新状态栏 ===
    QString message = QString("🎮 %1游戏连接成功").arg(m_currentGameLoginResult.serverInfo.gameType.toUpper());
    m_statusLabel->setText(message);
    m_connectionLabel->setText("已连接");
    m_connectionLabel->setStyleSheet("color: #27AE60;");

    qDebug() << "MainWindow: WebSocket认证完成，游戏大厅已显示";
}

/**
 * @brief WebSocket连接错误处理
 */
void MainWindow::onWebSocketConnectionError(const QString &error)
{
    qWarning() << "MainWindow: WebSocket连接错误:" << error;

    // === 显示认证失败 ===
    m_gameAuthProgressWidget->showAuthError("WebSocket连接失败: " + error);

    // === 更新状态栏 ===
    m_statusLabel->setText("WebSocket连接失败: " + error);
    m_connectionLabel->setText("连接失败");
    m_connectionLabel->setStyleSheet("color: #E74C3C;");
}

/**
 * @brief WebSocket认证失败处理
 */
void MainWindow::onWebSocketAuthenticationFailed(const QString &error)
{
    qWarning() << "MainWindow: WebSocket认证失败:" << error;

    // === 显示认证失败 ===
    m_gameAuthProgressWidget->showAuthError("WebSocket认证失败: " + error);

    // === 更新状态栏 ===
    m_statusLabel->setText("WebSocket认证失败: " + error);
    m_connectionLabel->setText("认证失败");
    m_connectionLabel->setStyleSheet("color: #E74C3C;");
}

/**
 * @brief 认证失败槽
 * @param error 错误信息
 *
 * 当游戏认证失败时调用
 */
void MainWindow::onAuthenticationFailed(const QString &error)
{
    qDebug() << "MainWindow: Game authentication failed:" << error;
    
    // === 更新状态栏 ===
    m_statusLabel->setText("认证失败: " + error);
    m_connectionLabel->setText("未连接");
    m_connectionLabel->setStyleSheet("color: #E74C3C;");
    
    // === 显示错误提示 ===
    auto *msg = new QMessageBox(QMessageBox::Warning, "认证失败",
        QString("游戏认证失败\n\n错误信息：%1\n\n请检查网络连接或稍后重试。").arg(error), QMessageBox::Ok, this);
    msg->setAttribute(Qt::WA_DeleteOnClose);
    msg->open();
}

/**
 * @brief 重试认证槽
 *
 * 当用户请求重试认证时调用
 */
void MainWindow::onRetryAuthentication()
{
    qDebug() << "MainWindow: Retrying game authentication";
    
    // === 更新状态栏 ===
    m_statusLabel->setText("正在重试认证...");
    m_connectionLabel->setText("连接中");
    m_connectionLabel->setStyleSheet("color: #F39C12;");
    
    // 注意：实际的重试逻辑会在GameAuthProgressWidget中处理
    // 这里主要是更新UI状态
}

/**
 * @brief 游戏认证成功槽
 * @param result 认证结果
 *
 * 当真实的游戏API认证成功时调用
 */
void MainWindow::onGameAuthenticationSucceeded(const GameService::GameLoginResult &result)
{
    qDebug() << "MainWindow: 游戏认证API调用成功";
    
    // 更新认证进度
    m_gameAuthProgressWidget->updateAuthStep(
        GameAuthProgressWidget::GettingToken, 
        "正在获取会话令牌..."
    );
    
    // 模拟获取令牌的过程
    QTimer::singleShot(500, this, [this, result]() {
        m_gameAuthProgressWidget->updateAuthStep(
            GameAuthProgressWidget::ConnectingGame, 
            "正在连接游戏服务器..."
        );
        
        // 模拟连接游戏服务器的过程，但不触发认证完成流程
        QTimer::singleShot(1000, this, [this, result]() {
            // 直接调用认证完成，不通过showAuthSuccess避免信号循环
            onAuthenticationCompleted(result);
        });
    });
}

/**
 * @brief 游戏认证失败槽
 * @param error 错误信息
 *
 * 当真实的游戏API认证失败时调用
 */
void MainWindow::onGameAuthenticationFailed(const QString &error)
{
    qDebug() << "MainWindow: 游戏认证API调用失败:" << error;
    
    // 直接显示认证失败
    m_gameAuthProgressWidget->showAuthError(error);
    
    // 更新状态栏
    m_statusLabel->setText("认证失败: " + error);
    m_connectionLabel->setText("未连接");
    m_connectionLabel->setStyleSheet("color: #E74C3C;");
}

/**
 * @brief 空白游戏页面准备就绪槽
 *
 * 当空白游戏页面加载完成并准备启动游戏时调用
 */
void MainWindow::onBlankGamePageReady()
{
    qDebug() << "MainWindow: 空白游戏页面准备就绪，开始启动具体游戏";

    const GameService::GameLoginResult &result = m_currentGameLoginResult;

    // === 调试游戏类型信息 ===
    qDebug() << "MainWindow: 检查游戏类型";
    qDebug() << "  原始游戏类型:" << result.serverInfo.gameType;
    qDebug() << "  小写游戏类型:" << result.serverInfo.gameType.toLower();
    qDebug() << "  服务器名称:" << result.serverInfo.name;
    qDebug() << "  服务器ID:" << result.serverInfo.serverId;

    // === 直接启动Snake游戏入口界面 ===
    // 目前只实现了Snake游戏，所以无论什么游戏类型都跳转到Snake游戏入口界面
    qDebug() << "MainWindow: 启动游戏入口界面，游戏类型:" << result.serverInfo.gameType;

    // === 保存游戏会话信息 ===
    m_currentGameSession.websocketUrl = QString("ws://%1:%2").arg(result.serverInfo.host).arg(result.serverInfo.port);
    m_currentGameSession.gameToken = result.sessionToken;
    m_currentGameSession.playerId = "player_" + QString::number(QDateTime::currentMSecsSinceEpoch());
    m_currentGameSession.playerName = "Player";

    // === 显示Snake游戏入口页面 ===
    showSnakeGameEntryPage();

    qDebug() << "MainWindow: 成功显示Snake游戏入口页面";
}

/**
 * @brief 游戏模式选择槽（暂时禁用）
 * @param mode 游戏模式 ("single", "multi", "room")
 *
 * 当用户在游戏入口界面选择游戏模式时调用
 */
void MainWindow::onGameModeSelected(const QString &mode)
{
    qDebug() << "MainWindow: 游戏模式选择:" << mode;

    if (mode == "single") {
        // 通知网络线程启动单人游戏
        if (m_networkThread) {
            qDebug() << "MainWindow: 通知网络线程启动单人游戏";
            QMetaObject::invokeMethod(m_networkThread, "startSinglePlayerGame", Qt::QueuedConnection);
        }

        // 启动现代化单人模式
        startModernSinglePlayerGame();
    } else {
        // 其他模式暂时禁用
        auto *msg = new QMessageBox(QMessageBox::Information, "功能开发中",
            QString("游戏模式 \"%1\" 正在开发中，敬请期待！\n\n目前仅支持单人模式。").arg(mode), QMessageBox::Ok, this);
        msg->setAttribute(Qt::WA_DeleteOnClose);
        msg->open();
    }
}

/**
 * @brief 皮肤设置请求槽
 *
 * 当用户点击皮肤设置按钮时调用
 */
void MainWindow::onSkinSettingsRequested()
{
    qDebug() << "MainWindow: 请求皮肤设置";

    // 显示皮肤设置界面（待实现）
    auto *msg = new QMessageBox(QMessageBox::Information, "皮肤设置",
        "🎨 皮肤设置功能即将推出！\n\n"
        "将支持以下功能：\n"
        "• 蛇的颜色主题\n"
        "• 游戏背景样式\n"
        "• 音效设置\n"
        "• 动画效果", QMessageBox::Ok, this);
    msg->setAttribute(Qt::WA_DeleteOnClose);
    msg->open();
}

/**
 * @brief 启动单人游戏模式
 *
 * 根据Snake Game服务文档实现单人模式：
 * 1. 创建SnakeGameWidget组件
 * 2. 初始化WebSocket连接
 * 3. 创建单人房间
 * 4. 开始游戏
 */
void MainWindow::startSinglePlayerGame()
{
    qDebug() << "MainWindow: 启动单人游戏模式";

    // === 创建现代化游戏控制器（如果尚未创建） ===
    if (!m_modernGameController) {
        m_modernGameController = new ModernGameController(this);

        // === 连接现代化游戏控制器信号 ===
        connect(m_modernGameController, &ModernGameController::gameStateChanged,
                this, [this](const QString &state) {
                    qDebug() << "MainWindow: 游戏状态变化:" << state;
                    if (state == "stopped") {
                        onBackToLobbyRequested();
                    }
                });

        connect(m_modernGameController, &ModernGameController::performanceStats,
                this, [this](int fps, int latency, float accuracy) {
                    qDebug() << "MainWindow: 性能统计 - FPS:" << fps
                             << "延迟:" << latency << "ms 准确率:" << (accuracy * 100) << "%";
                });

        qDebug() << "MainWindow: ModernGameController创建完成";
    }

    // === 检查WebSocket连接状态 ===
    if (!m_snakeGameManager || !m_snakeGameManager->isConnectedToGame()) {
        auto *msg = new QMessageBox(QMessageBox::Warning, "启动失败",
            "WebSocket连接未建立，请重新认证游戏服务器。", QMessageBox::Ok, this);
        msg->setAttribute(Qt::WA_DeleteOnClose);
        msg->open();
        return;
    }

    // === 使用保存的游戏会话信息 ===
    QString playerId = m_currentGameSession.playerId;
    QString playerName = m_currentGameSession.playerName;

    qDebug() << "MainWindow: 使用已建立的WebSocket连接启动单人游戏";
    qDebug() << "  playerId:" << playerId;
    qDebug() << "  playerName:" << playerName;
    qDebug() << "  WebSocket连接状态:" << (m_snakeGameManager->isConnectedToGame() ? "已连接" : "未连接");

    // === 将现代化游戏控制器添加到堆叠窗口（如果尚未添加） ===
    if (m_stackedWidget->indexOf(m_modernGameController) == -1) {
        m_stackedWidget->addWidget(m_modernGameController);
        qDebug() << "MainWindow: ModernGameController已添加到堆叠窗口";
    }

    // === 切换到现代化游戏界面 ===
    m_stackedWidget->setCurrentWidget(m_modernGameController);

    // === 隐藏侧边栏和菜单栏，专注游戏体验 ===
    m_sidebarWidget->setVisible(false);
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);

    // === 启动现代化游戏 ===
    ModernGameController::GameConfig config;
    config.targetFPS = 60;
    config.enablePrediction = true;   // 启用客户端预测，提升输入即时性
    config.enableInterpolation = true;
    config.enableEffects = true;
    config.serverUrl = m_currentGameSession.websocketUrl;

    // 将现有的WebSocket连接传递给ModernGameController
    m_modernGameController->setWebSocketManager(m_snakeGameManager);
    m_modernGameController->startGame(config);

    qDebug() << "MainWindow: 单人游戏启动完成 - 等待WebSocket连接和认证";
}

/**
 * @brief 启动现代化单人游戏模式
 *
 * 使用优化后的统一渲染架构和直接数据通道
 */
void MainWindow::startModernSinglePlayerGame()
{
    qDebug() << "MainWindow: 启动优化后的现代化单人游戏模式";

    // 由网络线程负责网络连接；即使暂未标记connected，也先进入控制器界面，避免“误判未连”阻断流程
    if (!m_networkThread) {
        auto *msg = new QMessageBox(QMessageBox::Warning, "连接错误",
            "网络线程未创建，无法启动游戏。", QMessageBox::Ok, this);
        msg->setAttribute(Qt::WA_DeleteOnClose);
        msg->open();
        return;
    }

    // 延迟创建DirectDataChannel，确保渲染器就绪后再启动
    qDebug() << "MainWindow: DirectDataChannel将在渲染器就绪后创建和启动";

    // === 单实例守护：清理旧的游戏控制器 ===
    if (m_modernGameController) {
        qDebug() << "MainWindow: 检测到旧的游戏控制器，先清理";

        // 断开所有连接
        disconnect(m_modernGameController, nullptr, this, nullptr);

        // 从堆叠窗口移除
        m_stackedWidget->removeWidget(m_modernGameController);

        // 延迟删除
        m_modernGameController->deleteLater();
        m_modernGameController = nullptr;

        qDebug() << "MainWindow: 旧游戏控制器已清理";
    }

    // === 清理旧的DirectDataChannel ===
    if (m_directDataChannel) {
        qDebug() << "MainWindow: 清理旧的DirectDataChannel";
        m_directDataChannel->stop();
        m_directDataChannel->deleteLater();
        m_directDataChannel = nullptr;
    }

    // 创建现代化游戏控制器
    m_modernGameController = new ModernGameController(this);
    m_stackedWidget->addWidget(m_modernGameController);

    // 诊断：检查堆叠窗口状态
    qDebug() << "=== 堆叠窗口诊断 ===";
    qDebug() << "堆叠窗口总组件数:" << m_stackedWidget->count();
    for (int i = 0; i < m_stackedWidget->count(); ++i) {
        QWidget *widget = m_stackedWidget->widget(i);
        qDebug() << "  索引" << i << ":" << widget->metaObject()->className()
                 << "(" << widget << ") 可见:" << widget->isVisible();
    }

    // 连接游戏控制器信号（修复：避免意外页面切换）
    if (m_modernGameController) {
        connect(m_modernGameController, &ModernGameController::backToLobby,
                this, [this]() {
                    qDebug() << "收到backToLobby信号，但在优化模式下保持当前页面";
                    // 不切换页面，保持在ModernGameController
                });
        connect(m_modernGameController, &ModernGameController::gameError,
                this, [this](const QString &error) {
                    qWarning() << "游戏错误:" << error;
                    // 使用非阻塞HUD提示，不使用模态对话框
                    if (m_modernGameController) {
                        // 通过游戏控制器显示HUD错误提示
                        QTimer::singleShot(0, this, [this, error]() {
                            // 可以在这里添加HUD错误显示逻辑
                            qWarning() << "游戏错误HUD提示:" << error;
                        });
                    }
                });

        // 连接方向改变信号到网络线程
        connect(m_modernGameController, &ModernGameController::directionChangeRequested,
                this, [this](int direction) {
                    if (m_networkThread) {
                        // 构建方向改变消息
                        QJsonObject directionMsg;
                        directionMsg["type"] = "change_direction";
                        directionMsg["direction"] = direction;

                        qDebug() << "MainWindow: 转发方向改变到网络线程:" << direction;
                        m_networkThread->sendMessage(directionMsg);
                    } else {
                        qWarning() << "MainWindow: 网络线程未初始化，无法发送方向改变";
                    }
                });
    }

    // 创建直接数据通道（如果尚未创建）
    if (!m_directDataChannel) {
        m_directDataChannel = new DirectDataChannel(this);

        // 不再连接主线程的WebSocket，消息通过网络线程传递
        qDebug() << "MainWindow: DirectDataChannel将通过网络线程接收消息";

        // 连接UI更新信号
        connect(m_directDataChannel, &DirectDataChannel::gameStateChanged,
                this, &MainWindow::onGameStateInfoChanged);
        connect(m_directDataChannel, &DirectDataChannel::gameEnded,
                this, &MainWindow::onGameEnded);
        connect(m_directDataChannel, &DirectDataChannel::connectionError,
                this, &MainWindow::onConnectionError);
        connect(m_directDataChannel, &DirectDataChannel::gameError,
                this, &MainWindow::onGameError);
    }

    // 延迟连接到UnifiedGameRenderer，确保渲染器已启动
    // 这将在startOptimizedGame中处理

    // DirectDataChannel的启动现在在startOptimizedGame中延迟处理

    // 不再设置主线程的WebSocket管理器，使用网络线程
    qDebug() << "MainWindow: 使用专用网络线程，不设置主线程WebSocket管理器";

    // 切换到游戏界面
    switchToOptimizedGameInterface();

    // 启动优化游戏（不再调用旧的startSinglePlayerGame）
    startOptimizedGame();
}

/**
 * @brief 显示Snake游戏页面
 *
 * 切换到Snake游戏页面，保持侧边栏可见
 */

/**
 * @brief Snake游戏关闭槽
 *
 * 处理Snake游戏界面关闭，返回主页面
 */

/**
 * @brief 返回主菜单槽
 *
 * 从Snake游戏返回主菜单
 */

/**
 * @brief 退出游戏槽函数
 *
 * 当用户在游戏中点击退出游戏按钮时调用，返回游戏服务器选择界面
 */
void MainWindow::onExitGameClicked()
{
    qDebug() << "MainWindow: 用户请求退出游戏";

    // === 清理游戏状态 ===
    // 旧SnakeGameWidget路径已移除，无需清理

    if (m_snakeGameEntryWidget) {
        m_snakeGameEntryWidget->hide();
    }

    // === 重置游戏认证进度组件状态 ===
    if (m_gameAuthProgressWidget) {
        m_gameAuthProgressWidget->resetAuthentication();
        m_gameAuthProgressWidget->hide();
        qDebug() << "MainWindow: 重置游戏认证进度组件状态";
    }

    // === 恢复侧边栏退出按钮为正常模式 ===
    m_sidebarWidget->setExitButtonMode(false);

    // === 返回游戏服务器选择界面 ===
    m_stackedWidget->setCurrentWidget(m_gameServerWidget);

    // === 确保主界面布局正常 ===
    if (centralWidget() != m_centralWidget) {
        setCentralWidget(m_centralWidget);
    }

    // === 显示侧边栏、菜单栏和状态栏 ===
    m_sidebarWidget->setVisible(true);
    menuBar()->setVisible(true);
    statusBar()->setVisible(true);

    // === 更新窗口标题 ===
    setWindowTitle("游戏平台 - 选择游戏服务器");

    // === 显示状态消息 ===
    statusBar()->showMessage("已退出游戏，返回服务器选择界面", 3000);

    qDebug() << "MainWindow: 成功退出游戏并返回服务器选择界面";
}

/**
 * @brief 处理返回大厅请求
 */
void MainWindow::onBackToLobbyRequested()
{
    qDebug() << "MainWindow: 收到返回大厅请求";

    // === 检查WebSocket连接状态 ===
    if (m_snakeGameManager) {
        bool isConnected = m_snakeGameManager->isConnectedToGame();
        qDebug() << "MainWindow: WebSocket连接状态:" << (isConnected ? "已连接" : "未连接");

        if (isConnected) {
            qDebug() << "MainWindow: WebSocket连接保持正常，可以继续游戏";
        } else {
            qWarning() << "MainWindow: WebSocket连接已断开，可能需要重新连接";
        }
    }

    // === 切换到现代化Snake游戏入口页面 ===
    m_stackedWidget->setCurrentWidget(m_snakeGameEntryWidget);

    // === 显示侧边栏和菜单栏 ===
    m_sidebarWidget->setVisible(false);  // 保持隐藏，专注游戏体验
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);

    // === 调整窗口大小 ===
    resize(1400, 900);

    // === 更新窗口标题 ===
    setWindowTitle("Snake Game - 游戏大厅");

    qDebug() << "MainWindow: 已返回到现代化游戏大厅，WebSocket连接保持";
}

// === Snake游戏大厅相关方法实现 ===

/**
 * @brief 显示Snake游戏大厅页面
 * @param websocketUrl WebSocket连接URL
 * @param gameToken 游戏认证令牌
 * @param playerId 玩家ID
 * @param playerName 玩家名称
 */
void MainWindow::showSnakeGameLobby(const QString &websocketUrl, const QString &gameToken,
                                   const QString &playerId, const QString &playerName)
{
    qDebug() << "MainWindow: 显示现代化Snake游戏大厅页面";
    qDebug() << "  WebSocket URL:" << websocketUrl;
    qDebug() << "  Player ID:" << playerId;
    qDebug() << "  Player Name:" << playerName;
    qDebug() << "  Token Length:" << gameToken.length();

    // === 保存游戏会话信息供后续使用 ===
    m_currentGameSession.websocketUrl = websocketUrl;
    m_currentGameSession.gameToken = gameToken;
    m_currentGameSession.playerId = playerId;
    m_currentGameSession.playerName = playerName;

    // === 切换到现代化Snake游戏入口页面 ===
    m_stackedWidget->setCurrentWidget(m_snakeGameEntryWidget);

    // === 隐藏侧边栏和菜单栏，专注游戏体验 ===
    m_sidebarWidget->setVisible(false);
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);

    // === 调整窗口大小为游戏模式 ===
    resize(1400, 900);

    // === 更新窗口标题 ===
    setWindowTitle("Snake Game - 游戏大厅");

    // === 设置玩家信息 ===
    m_snakeGameEntryWidget->setPlayerInfo(playerId, playerName);

    qDebug() << "MainWindow: 现代化Snake游戏大厅页面显示完成";
}

// === 优化架构方法实现 ===

void MainWindow::switchToOptimizedGameInterface()
{
    qDebug() << "=== 页面切换诊断 ===";
    qDebug() << "当前页面:" << m_stackedWidget->currentWidget();
    qDebug() << "目标页面:" << m_modernGameController;
    qDebug() << "ModernGameController可见:" << (m_modernGameController ? m_modernGameController->isVisible() : false);
    qDebug() << "堆叠窗口子组件数:" << m_stackedWidget->count();

    // 切换到ModernGameController界面
    m_stackedWidget->setCurrentWidget(m_modernGameController);

    // 确保ModernGameController可见和活跃
    if (m_modernGameController) {
        m_modernGameController->show();
        m_modernGameController->raise();
        m_modernGameController->activateWindow();
        m_modernGameController->setFocus();
    }

    // 隐藏UI元素，专注游戏体验
    m_sidebarWidget->setVisible(false);
    menuBar()->setVisible(false);
    statusBar()->setVisible(false);

    // 设置窗口标题
    setWindowTitle("Snake游戏 - 优化模式");

    qDebug() << "切换后当前页面:" << m_stackedWidget->currentWidget();
    qDebug() << "切换后ModernGameController可见:" << (m_modernGameController ? m_modernGameController->isVisible() : false);
    qDebug() << "MainWindow: 已切换到优化游戏界面";
}

void MainWindow::startOptimizedGame()
{
    qDebug() << "MainWindow: 启动优化游戏";

    // 确保ModernGameController是当前显示的页面
    if (m_stackedWidget->currentWidget() != m_modernGameController) {
        qWarning() << "当前页面不是ModernGameController，强制切换";
        m_stackedWidget->setCurrentWidget(m_modernGameController);
    }

    // 确保ModernGameController可见
    if (m_modernGameController && !m_modernGameController->isVisible()) {
        qWarning() << "ModernGameController不可见，强制显示";
        m_modernGameController->show();
        m_modernGameController->raise();
        m_modernGameController->activateWindow();
    }

    // 初始化游戏数据对象池
    if (!m_gameDataPool) {
        m_gameDataPool = GameDataPool::instance();
        // 预热对象池
        m_gameDataPool->warmup(15, 25, 20);
    }

    // 配置统一渲染器参数（不再使用旧的ModernGameController::startGame）
    UnifiedGameRenderer::RenderConfig renderConfig;
    renderConfig.targetFPS = 60;
    renderConfig.enableEffects = true;
    renderConfig.enableInterpolation = true;
    renderConfig.enablePrediction = true;  // 与客户端预测保持一致
    renderConfig.renderSize = QSize(800, 600);

    // 启动ModernGameController的游戏状态（包含统一渲染器）
    qDebug() << "MainWindow: 启动ModernGameController游戏状态";
    ModernGameController::GameConfig gameConfig;
    gameConfig.targetFPS = 60;
    gameConfig.enableEffects = true;
    gameConfig.serverUrl = m_currentGameSession.websocketUrl;

    // 检查是否已经在运行，避免重复启动
    if (m_modernGameController && m_modernGameController->getUnifiedRenderer()) {
        auto renderer = m_modernGameController->getUnifiedRenderer();
        if (renderer->isRunning()) {
            qDebug() << "MainWindow: 游戏已在运行，跳过重复启动";
            return;
        }
    }

    m_modernGameController->startGame(gameConfig);

    // 等待一小段时间确保UnifiedGameRenderer启动
    QTimer::singleShot(200, this, [this]() {
        // 现在连接DirectDataChannel到UnifiedGameRenderer
        if (m_directDataChannel && m_modernGameController && m_modernGameController->getUnifiedRenderer()) {
            auto renderer = m_modernGameController->getUnifiedRenderer();
            if (renderer->isRunning()) {
                m_directDataChannel->connectRenderer(renderer);
                qDebug() << "MainWindow: DirectDataChannel已连接到运行中的UnifiedGameRenderer";

                // 启动DirectDataChannel
                m_directDataChannel->start();
                qDebug() << "MainWindow: DirectDataChannel已启动";

                // 渲染管线就绪，现在可以通知网络线程发送create_room
                qDebug() << "MainWindow: 渲染管线就绪，通知网络线程发送create_room";
                notifyNetworkThreadToStart();
            } else {
                qWarning() << "MainWindow: UnifiedGameRenderer未运行，延迟连接";
                // 再次延迟尝试
                QTimer::singleShot(500, this, [this]() {
                    if (m_directDataChannel && m_modernGameController && m_modernGameController->getUnifiedRenderer()) {
                        auto renderer = m_modernGameController->getUnifiedRenderer();
                        m_directDataChannel->connectRenderer(renderer);
                        m_directDataChannel->start();
                        qDebug() << "MainWindow: DirectDataChannel延迟启动完成";

                        // 渲染管线就绪，现在可以通知网络线程发送create_room
                        qDebug() << "MainWindow: 渲染管线延迟就绪，通知网络线程发送create_room";
                        notifyNetworkThreadToStart();
                    }
                });
            }
        } else {
            qCritical() << "MainWindow: 无法连接DirectDataChannel - 组件缺失";
        }
    });

    qDebug() << "MainWindow: 优化游戏启动完成";
    qDebug() << "最终页面状态 - 当前页面:" << m_stackedWidget->currentWidget();
    qDebug() << "最终页面状态 - ModernGameController可见:" << (m_modernGameController ? m_modernGameController->isVisible() : false);

    // === 检查是否存在多重界面 ===
    qDebug() << "=== 界面重叠检查 ===";
    qDebug() << "堆叠窗口总组件数:" << m_stackedWidget->count();
    for (int i = 0; i < m_stackedWidget->count(); ++i) {
        QWidget* widget = m_stackedWidget->widget(i);
        qDebug() << "  索引" << i << ":" << widget << "可见:" << widget->isVisible();
    }

    // 已移除旧SnakeGameWidget，不存在重叠界面
    // 确保只有ModernGameController可见
    if (m_modernGameController) {
        m_modernGameController->show();
        m_modernGameController->raise();
        m_modernGameController->activateWindow();
        m_modernGameController->setFocus();
        qDebug() << "强制显示ModernGameController并设置焦点";
    }
}

void MainWindow::notifyNetworkThreadToStart()
{
    qDebug() << "MainWindow: 通知网络线程开始发送create_room";

    if (m_networkThread) {
        // 通过信号通知网络线程渲染管线已就绪，可以发送create_room
        QMetaObject::invokeMethod(m_networkThread, "onRenderPipelineReady", Qt::QueuedConnection);
    } else {
        qWarning() << "MainWindow: 网络线程不存在，无法通知";
    }
}

void MainWindow::onGameStateInfoChanged(const GameStateInfo &info)
{
    // 更新状态栏显示
    QString statusText = QString("分数: %1 | 存活玩家: %2/%3 | 状态: %4")
                        .arg(info.score)
                        .arg(info.alivePlayers)
                        .arg(info.totalPlayers)
                        .arg(info.gameStatus);

    if (statusBar()) {
        statusBar()->showMessage(statusText);
    }

    // 更新窗口标题
    setWindowTitle(QString("Snake游戏 - 分数: %1").arg(info.score));
}

void MainWindow::onGameEnded(const QString &reason)
{
    qDebug() << "MainWindow: 游戏结束，原因:" << reason;

    // 使用非阻塞方式显示游戏结束消息
    QTimer::singleShot(0, this, [this, reason]() {
        QMessageBox *msgBox = new QMessageBox(QMessageBox::Information,
                                             "游戏结束",
                                             QString("游戏已结束\n原因: %1").arg(reason),
                                             QMessageBox::Ok, this);
        msgBox->setAttribute(Qt::WA_DeleteOnClose);
        msgBox->open();
    });

    // 停止直接数据通道
    if (m_directDataChannel) {
        m_directDataChannel->stop();
    }

    // 在优化模式下保持当前页面，不切换到其他页面
    qDebug() << "游戏结束，保持在当前优化界面";
}

void MainWindow::onConnectionError(const QString &error)
{
    qCritical() << "MainWindow: 连接错误:" << error;

    // 显示错误消息
    auto *msg = new QMessageBox(QMessageBox::Critical, "连接错误",
        QString("网络连接出现问题:\n%1\n\n请检查网络连接后重试。").arg(error), QMessageBox::Ok, this);
    msg->setAttribute(Qt::WA_DeleteOnClose);
    msg->open();

    // 停止直接数据通道
    if (m_directDataChannel) {
        m_directDataChannel->stop();
    }

    // 在优化模式下保持当前页面，不切换到其他页面
    qDebug() << "连接错误，保持在当前优化界面";
}

void MainWindow::onGameError(const QString &error)
{
    qCritical() << "MainWindow: 游戏错误:" << error;

    // 显示错误消息
    auto *msg = new QMessageBox(QMessageBox::Critical, "游戏错误",
        QString("游戏运行出现错误:\n%1").arg(error), QMessageBox::Ok, this);
    msg->setAttribute(Qt::WA_DeleteOnClose);
    msg->open();

    // 注意：业务类游戏错误不应停止数据通道，保持渲染与网络继续运行
    // 仅提示用户，后续仍可收到状态更新

    // 在优化模式下保持当前页面，不切换到其他页面
    qDebug() << "游戏错误，保持在当前优化界面";
}

void MainWindow::onNetworkGameMessage(const QJsonObject &message)
{
    QString messageType = message["type"].toString();
    qDebug() << "MainWindow: 收到网络线程游戏消息，类型:" << messageType;

    // 将消息转发给DirectDataChannel处理
    if (m_directDataChannel) {
        // 通过异步调用，避免在UI线程内做重活
        QMetaObject::invokeMethod(
            m_directDataChannel,
            "onWebSocketMessage",
            Qt::QueuedConnection,
            Q_ARG(QJsonObject, message)
        );
    } else {
        qWarning() << "MainWindow: DirectDataChannel未初始化，无法处理消息";
    }
}


